long[] dp = new long[N+1];			
			dp[1] = 1;
			dp[2] = 1;
			dp[3] = 1;
			dp[4] = 2;
			
			for (int i=5; i<N+1; i++) {
				dp[i] = dp[i-1]+dp[i-5];
			}

    // BFS를 통해 먹을 수 있는 물고기 후보 중 최단거리, 위, 왼쪽 순으로 x, y좌표, 거리 return
    // 찾지 못하면 null return
    public static int[] bfs(int startX, int startY) {
        boolean[][] visited = new boolean[N][N];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{startX, startY, 0});
        visited[startX][startY] = true;
        
        List<int[]> fish = new ArrayList<>();
        int minDistance = Integer.MAX_VALUE;
        
        while(!queue.isEmpty()){
            int[] cur = queue.poll();
            int x = cur[0], y = cur[1], dist = cur[2];
            
            // 만약 현재까지의 최단거리보다 더 먼 경로라면 continue
            if(dist > minDistance) continue;
            
            // 먹을 수 있는 물고기일 경우
            if(map[x][y] != 0 && map[x][y] < sharkSize) {
                // 첫 후보 발견시 minDistance 업데이트하고
            	// 기존 물고기 리스트 갱신
                if(dist < minDistance) {
                    minDistance = dist;
                    fish.clear();
                    fish.add(new int[]{x, y});
                } else if(dist == minDistance) { // 같은 거리에 여러 후보가 있다면 리스트에 추가
                	fish.add(new int[]{x, y});
                }
            }
            
            for (int i = 0; i < 4; i++){
                int nx = x + dx[i];
                int ny = y + dy[i];
                if(isOK(nx, ny) && !visited[nx][ny] && map[nx][ny] <= sharkSize) {
                    visited[nx][ny] = true;
                    queue.offer(new int[]{nx, ny, dist + 1});
                }
            }
        }
        
        if(fish.isEmpty()) return null;
        
        // 행 번호가 가장 작은 물고기, 행 번호가 같으면 열 번호가 가장 작은 물고기 선택
        Collections.sort(fish, new Comparator<int[]>() {
            public int compare(int[] o1, int[] o2){
                if(o1[0] != o2[0]) 
                    return o1[0] - o2[0];
                return o1[1] - o2[1];
            }
        });
        
        int[] chosen = fish.get(0);
        return new int[]{chosen[0], chosen[1], minDistance};
    }

		while(!q.isEmpty()) {
			int[] cur = q.poll();
			
			for (int j=0; j<8; j++) {
				int nx = cur[0] + dx[j];
				int ny = cur[1] + dy[j];
				
				if (!isOK(nx, ny) || visited[nx][ny] >= cnt) continue;
				
				q.add(new int[] {nx, ny});
				visited[nx][ny]++;
				
				if (visited[nx][ny] == 1) {
					result[nx][ny] = result[cur[0]][cur[1]]+1;
				} else {
					result[nx][ny] = Math.min(result[cur[0]][cur[1]]+1, result[nx][ny]);
				}
			}
		}

		int[] dp = new int[K+1];
		dp[0] = 1;
		
		for (int i=coin[1]; i<K+1; i+=coin[1]) {
			dp[i] = 1;
		}
		
		for (int i=2; i<N+1; i++) {
			for (int j=K; j>=0; j--) {
				if (coin[i] > j) continue;
				for (int k=j-coin[i]; k>=0; k-=coin[i]) dp[j] += dp[k];
			}
		}

// k 정점을 거쳐가는 경우 모두 계산
        for (int i=1; i < N+1; i++) { // 중간 정점
        	 for (int j=1; j < N+1; j++) {
        		 if (dist[j][i] == 10000000) continue;
        		 for (int k=1; k < N+1; k++) {
        			 if (dist[i][k] == 10000000) continue;
        			 if (dist[j][i] + dist[i][k] < dist[j][k]) {
        				 dist[j][k] = dist[j][i] + dist[i][k];
        			 }
        		 }
        	 }
        }